IDIOT COMPILER ( PARSER MODE ) rev 1.67
NASPITE LABS (c) 2018


TABLE OF CONTENTS
  1.  INTRODUCTION
  2.  GETTING TO WORK - (BASIC HOW-TO)
  3.  USE THE PARSER or USE REGULAR MODE?
  4.  TURN ON AUTOMATIC PARSER (V1.65)
  5.  BUGS AND FEEDBACK... THIS THING IS NEW AFTER-ALL!


=============================================================
1.  INTRODUCTION

The NEWEST addition to iDIOT COMPILER is the PARSER Technology!

Parser Technology bridges the gap of APPLESOFT code structure 
and the process to assemblize the code, allowing easier transfers
of created APPLESOFT to pure fast ASM, just about as good as
hand assembled code without a TON of hassle and memory management.

***NOTE, the process to run the PARSER mode is fully compatible
with IIE/IIC/IIGS computers, but is recommended to run in an
emulator for greater speedup of code generation/translation.

Lets get down to the brass tax.  If you have read the manual
and know the limitations, lets go full speed ahead into the PARSER.


=============================================================
2.  GETTING TO WORK - (BASIC HOW-TO)

**The PARSER is a seperate module to IDIOT Compiler which 
must be activated by typing PARSER in the main program.
In actuality, the PARSER is modified Compiler that changes
all the human inputs to a standard automated input system.

The PARSER technology shares its final compile process with REGULAR
standard mode... as such it is reccomended to RESET the compiler
before starting any new project.

1.  Create your APPLESOFT program in accordance to the guidelines
in the REGULAR mode manual.  SAVE your program, and then move/copy
it to the IDIOT Compiler Diskette.

****NOTICE========================================================
There are many things it currently cannot do and will never do.
If you want an ALL-IN-ONE solution, the commerical compilers
are a better overall package and much less hassle free.

Consider this COMPILER to be an Applesoft Assembler.  The output code
is/can be multiple times faster than its nearest competetor on the things 
that it does do, so examine your Applesoft program and see if its out of 
the scope of this compiler before attemting to
assemblize it.

	It does not do	COMPLEX MATH
			NEGATIVE NUMBERS
			STRING VARIABLES
			#'s ABOVE 24 BIT (*16,777,216)
     ======================================================

2.  FRESH/COLD BOOT the COMPILER disk.  Make sure you have moved/copied
your applesoft program to the disk before starting.

3.  Type  RESET if you are working on an entirely new project.
It is possible to continue working on a project, before and after the
automatic parsing portion covered in this manual.
    The FOR/NEXT loop prompt is to tell the compiler how deeply nested
you are expecting FOR/NEXT loops to be and issues variable space accordingly.
Usually a value of 1 or 2 is sufficient for most cases.

4.  After the Compiler is RESET (or not if continuing a project)... type
PARSER at the prompt.  A few seconds later, it will ask you for your
APPLESOFT program to translate.  Type its name and press ENTER.

At this point, it will start parsing the APPLESOFT and you will see both
strange and familure numbers/commands being displayed on the screen.


IF the Compiler stops with a prompt on the...
	LEFT SIDE-   an error has occurred.  This could be an internal
	error, an APPLESOFT statement error, or trying to do something
	the compiler is not capable of doing.  

	L1. The first course of action is to list the program at the 
	intererpter and see if there are any problems, especially with 
	how VARIABLES are.  APPLESOFT will sometimes split up variables 
	incorrectly if a hardwired KEYWORD is included... an example...
		TOM=BOB  will show up as  TO M=BOB and will not
		parse correctly, either in IDIOT or the INTERPETER.

	L2.  If there is something else wrong, its most likely attempting
	to create/translate code it is not currently designed to do.
	If you believe its a legal statement, contact NASPITE as it could
	be a bug which can be corrected.

	RIGHT SIDE-  most of the time when the compiler stops on the RIGHT
	side, it is actually waiting for a PROMPT.  WHAT... a compiler 
	asking questions?  Yes, it is waiting for an input to determin
	what BIT-LEVEL the math you wish to use.  Idiot is designed to
	function like this in order to customize your code specificly
	for your application.  You will see a prompt....
		A = B + C	
		1-8BIT  / 2 - 16BIT  / 3- 24BIT
	
	HIT the key 1/2/3 and it will generate code for that instance.
	It is a good idea to follow along with IDIOT compiler as it generates
	your code.  There are places where 8bit math is very acceptable and
	will speedup your program to 'near handwritten' machine speed, if not
	equal to it.  Or choose 16bit if you need larger interger number
	capability.  Idiot is the ONLY compiler that gives you these options!

5.  	If the program does finish compiling, you will be met with:
	CONVERSION COMPLETE - REBOOT COMPILER.
	Please do a full reboot on the compiler disk.

6. 	If there are any code lines to add manually, you may do so now.
	When finished, type COMPILE and choose Y.  After a successful
	compile, you will be prompted to save your new program.  TYPE
	the name you wish to call your new ASM program... and then watch
	it finish up.  It will leave you at the APPLESOFT prompt when 
	finished.
	
	***In the advent of it failing to compile, it usually will give
	you an error message.  The message usually will be because a LINE#
	was referenced somewhere but not subsequently created. You can create
	the line in manual mode and then COMPILE again.

	(Other error messages could be....)
	***The variable table could be corrupted.-  
		This may require a full recompile from reset.  
		Usually working on two projects at the same time
	***Line does not exist or could be empty. (or) No Such Line
	***Length of Instruction too small (this is internal compiler error)
	***No such Special Command (internal compiler error)

	*If a program does fail to PARSE or COMPILE, you are encourage to 
	contact NASPITE for advice.  If possible, have the disk image and
	the original source (Applesoft Program) handy to analyze.
===========================================================


3.  USE THE PARSER or USE REGULAR MODE?

	For the most part, the PARSER can perform all the functions of
	REGULAR mode.  It also eliminates possible typing errors that
	could be entered.  That being said, you can mix and match modes
	if it suits the purpose.  Almost all of the SPECIAL code generation
	is incorperated in the parsing automatically... so an example of
	A=A+1 will generate faster code then a generic addition routine.

	There are 'targeted instances' where a manual entry can create
	better code than even the integrated SPECIALS.  Here is an example.

EXAMPLE:
	The REGULAR mode has special sections to allow special inputs of
	code that can speed up the translation execution of APPLESOFT
	into ASM.  For people that know assembly language, here is an
	example from the COMPILER manual...

		Say you have the basic commands:  
		( POKE 35000,0:POKE 35001,0:POKE 35002,0)
		By using the compiler with the poke command, 
		you code will look like this.
			POKE	LDA #0
				STA 35000
			POKE	LDA #0
				STA 35001
			POKE	LDA #0
				STA 35002
		In the overall skeme of things, its not bad for a compiler... 
		but in DIRECT ASM MODE, you could type in this...
			ASM	ASM: LDA #0
				ASM: STA 35000
				ASM: STA 35001
				ASM: STA 35002
				ASM: END

	**  In PARSER mode, you do not have ASM capability, so the POKE METHOD
	will be the default method choice code generation.
===========================================================
  4.  TURN ON AUTOMATIC PARSER (V1.65)

	The PARSER is a semi-manual mode, which stops at all variable entry
	points and asks for a bit level to process a particular EQUATION and
	IF statement.  If you wish to turn on AUTOMATIC PARSER or TURN IT OFF
	please look at the text file (PARSER AUTO PATCH) in the COMPILER foler!

===========================================================

  5.  BUGS AND FEEDBACK... THIS THING IS NEW AFTER-ALL!

	IDIOT COMPILER is still in flux and change.  What started out as an
	exercise to help with ASSEMBLY programming language has evolved into
	a full fledge compiler.

	The PARSER technology is brand new, and there may be bugs.  But there
	are also many possible reasons why a series of code 'seems' to fail
	to compile.  Most of these are formatting issues.  We will keep at it
	and bug fix as problems rise to the surface.

	Contact us at treehouse2000us@yahoo.com if you beleive you have found
	a bug, and or ideas for new functions and features, or if you want to
	submit your own assembly code subroutine to help make IDIOT COMPILER
	better.  

	We appreciate feedback, and THANK YOU for looking into IDIOT COMPILER
								APPLESOFT-ASSEMBLER!


						-Tom at Naspite Labs




